home *** CD-ROM | disk | FTP | other *** search
/ Aminet 5 / Aminet 5 - March 1995.iso / Aminet / dev / misc / LEDA_gene.lha / LEDA-3.1c-generic / incl / LEDA / segment.h < prev    next >
Encoding:
C/C++ Source or Header  |  1994-11-10  |  3.4 KB  |  134 lines
  1. /*******************************************************************************
  2. +
  3. +  LEDA  3.1c
  4. +
  5. +
  6. +  segment.h
  7. +
  8. +
  9. +  Copyright (c) 1994  by  Max-Planck-Institut fuer Informatik
  10. +  Im Stadtwald, 6600 Saarbruecken, FRG     
  11. +  All rights reserved.
  12. + 
  13. *******************************************************************************/
  14.  
  15.  
  16. #ifndef LEDA_SEGMENT_H
  17. #define LEDA_SEGMENT_H
  18.  
  19. #include <LEDA/point.h>
  20.  
  21. //------------------------------------------------------------------------------
  22. // segments
  23. //------------------------------------------------------------------------------
  24.  
  25.  
  26. class segment_rep : public handle_rep {
  27.  
  28. friend class segment;
  29. friend class line;
  30. friend class circle;
  31.    
  32.    point start;
  33.    point end;
  34.  
  35.    double slope;
  36.    double y_abs;
  37.    double angle;
  38.  
  39. public:
  40.    
  41.    segment_rep(const point&, const point&);
  42.    segment_rep();  
  43.  
  44.   ~segment_rep() {}
  45.  
  46.    
  47.    LEDA_MEMORY(segment_rep)
  48.    
  49. };
  50.  
  51.  
  52. class segment  : public handle_base 
  53. {
  54.  
  55. friend class line;
  56. friend class circle;
  57.  
  58. segment_rep* ptr() const { return (segment_rep*)PTR; }
  59.  
  60. public:
  61.  
  62.  segment();                 
  63.  segment(const point&, const point&); 
  64.  segment(double, double, double, double) ;
  65.  segment(const point&, double dir, double length);
  66.  segment(const segment& s) : handle_base(s) {}     
  67. ~segment()                { clear(); }
  68.  
  69. segment& operator=(const segment& s) { handle_base::operator=(s); return *this;}
  70.  
  71. operator vector()  { return vector(xcoord2()-xcoord1(), ycoord2()-ycoord1()); }
  72.  
  73. bool intersection(const segment& s, point& inter) const;
  74.  
  75. point start()  const      { return ptr()->start; }
  76. point end()    const      { return ptr()->end; }
  77.  
  78. double xcoord1() const    { return ptr()->start.ptr()->x; }
  79. double xcoord2() const    { return ptr()->end.ptr()->x;   }
  80. double ycoord1() const    { return ptr()->start.ptr()->y; }
  81. double ycoord2() const    { return ptr()->end.ptr()->y;   }
  82.  
  83. double slope() const { return ptr()->slope; }
  84. double y_abs() const { return ptr()->y_abs; }
  85.  
  86. double angle()     const { return ptr()->angle; }
  87. double direction() const { return angle(); }
  88.  
  89. bool vertical()   const { return xcoord1() == xcoord2(); }
  90. bool horizontal() const { return ycoord1() == ycoord2(); }
  91.  
  92. double length() const { return start().distance(end()); }
  93.  
  94. segment translate(double,double) const;
  95. segment translate(const vector&) const;
  96.  
  97. double  angle(const segment&) const;
  98.  
  99. double  distance(const segment&) const;
  100. double  distance(const point&) const;
  101. double  distance() const;
  102. double  x_proj(double) const;
  103. double  y_proj(double) const;
  104.  
  105. double operator()(double x) { return y_proj(x); }
  106.  
  107. segment rotate(const point&,double) const;
  108. segment rotate(double) const;
  109.  
  110. bool  right()  const     { return ptr()->start.ptr()->x < ptr()->end.ptr()->x; }
  111. bool  left()   const     { return ptr()->start.ptr()->x > ptr()->end.ptr()->x; }
  112. bool  up()     const     { return ptr()->start.ptr()->y < ptr()->end.ptr()->y; }
  113. bool  down()   const     { return ptr()->start.ptr()->y > ptr()->end.ptr()->y; }
  114.  
  115. segment operator+(const vector& v) const { return translate(v); }
  116.  
  117. int operator==(const segment& s) const
  118. { return (ptr()->start == s.ptr()->start && ptr()->end == s.ptr()->end); }
  119.  
  120. int operator!=(const segment& s) const { return !operator==(s);}
  121.  
  122. friend ostream& operator<<(ostream& out, const segment& s);
  123. friend istream& operator>>(istream& in, segment& s);
  124.  
  125. };
  126.  
  127. inline void Print(const segment& s, ostream& out) { out << s; } 
  128. inline void Read(segment& s,  istream& in)        { in >> s; }
  129.  
  130. LEDA_HANDLE_TYPE(segment)
  131.  
  132.  
  133. #endif
  134.